JavaScripti generaatorid: iteraatori protokolli rakendamise meisterlikkus

JavaScripti generaatorid on võimas funktsioon, mis võeti kasutusele ECMAScript 6-s (ES6) ja mis oluliselt laiendab keele võimekust iteratiivsete protsesside ja asünkroonse programmeerimise käsitlemisel. Need pakuvad unikaalset viisi iteraatorite defineerimiseks, võimaldades loetavamat, hooldatavamat ja efektiivsemat koodi. See põhjalik juhend süveneb JavaScripti generaatorite maailma, uurides nende funktsionaalsust, iteraatori protokolli rakendamist, praktilisi kasutusjuhtumeid ja täiustatud tehnikaid.

Iteraatorite ja iteraatori protokolli mõistmine

Enne generaatoritesse süvenemist on oluline mõista iteraatorite ja iteraatori protokolli kontseptsiooni. Iteraator on objekt, mis defineerib jada ja lõpetamisel potentsiaalselt ka tagastusväärtuse. Täpsemalt on iteraator iga objekt, millel on next() meetod, mis tagastab objekti kahe omadusega:

• value: Järgmine väärtus jadas.
• done: Kahendmuutuja, mis näitab, kas iteraator on lõpule jõudnud. true tähistab jada lõppu.

Iteraatori protokoll on lihtsalt standardne viis, kuidas objekt saab ennast itereeritavaks muuta. Objekt on itereeritav, kui see defineerib oma iteratsioonikäitumise, näiteks milliseid väärtusi tsüklitakse läbi for...of konstruktsioonis. Itereeritav olemiseks peab objekt implementeerima @@iterator meetodi, millele pääseb ligi Symbol.iterator kaudu. See meetod peab tagastama iteraatori objekti.

Paljud sisseehitatud JavaScripti andmestruktuurid, nagu massiivid, sõned, map'id ja set'id, on olemuslikult itereeritavad, sest nad rakendavad iteraatori protokolli. See võimaldab meil nende elemente hõlpsasti läbi käia, kasutades for...of tsükleid.

Näide: massiivi itereerimine

            const myArray = [1, 2, 3];

const iterator = myArray[Symbol.iterator]();

console.log(iterator.next()); // Väljund: { value: 1, done: false }
console.log(iterator.next()); // Väljund: { value: 2, done: false }
console.log(iterator.next()); // Väljund: { value: 3, done: false }
console.log(iterator.next()); // Väljund: { value: undefined, done: true }

for (const value of myArray) {
 console.log(value); // Väljund: 1, 2, 3
}

            

              
                Copy
              
            
          

JavaScripti generaatorite tutvustus

Generaator on eriline tüüpi funktsioon, mida saab peatada ja jätkata, võimaldades teil kontrollida andmete genereerimise voogu. Generaatorid defineeritakse kasutades function* süntaksit ja yield võtmesõna.

• function*: See deklareerib generaatorfunktsiooni. Generaatorfunktsiooni kutsumine ei käivita selle keha kohe; selle asemel tagastab see erilist tüüpi iteraatori, mida nimetatakse generaatori objektiks.
• yield: See võtmesõna peatab generaatori täitmise ja tagastab väärtuse kutsujale. Generaatori olek salvestatakse, mis võimaldab seda hiljem jätkata täpselt sealt, kus see peatati.

Generaatorfunktsioonid pakuvad lühikest ja elegantset viisi iteraatori protokolli rakendamiseks. Nad loovad automaatselt iteraatori objekte, mis tegelevad oleku haldamise ja väärtuste andmise keerukustega.

Näide: lihtne generaator

            function* numberGenerator() {
 yield 1;
 yield 2;
 yield 3;
}

const gen = numberGenerator();

console.log(gen.next()); // Väljund: { value: 1, done: false }
console.log(gen.next()); // Väljund: { value: 2, done: false }
console.log(gen.next()); // Väljund: { value: 3, done: false }
console.log(gen.next()); // Väljund: { value: undefined, done: true }

            

              
                Copy
              
            
          

Kuidas generaatorid rakendavad iteraatori protokolli

Generaatorfunktsioonid rakendavad iteraatori protokolli automaatselt. Kui defineerite generaatorfunktsiooni, loob JavaScript automaatselt generaatori objekti, millel on next() meetod. Iga kord, kui kutsute generaatori objektil next() meetodit, täidetakse generaatorfunktsiooni kuni yield võtmesõnani jõudmiseni. Väärtus, mis on seotud yield võtmesõnaga, tagastatakse next() poolt tagastatud objekti value omadusena ja done omadus seatakse väärtusele false. Kui generaatorfunktsioon lõpetab (kas jõudes funktsiooni lõppu või kohates return lauset), muutub done omadus true-ks ja value omadus seatakse tagastatavale väärtusele (või undefined, kui selgesõnalist return lauset pole).

Oluline on märkida, et generaatori objektid on ka ise itereeritavad! Neil on Symbol.iterator meetod, mis lihtsalt tagastab generaatori objekti enda. See muudab generaatorite kasutamise for...of tsüklite ja muude itereeritavaid objekte ootavate konstruktsioonidega väga lihtsaks.

JavaScripti generaatorite praktilised kasutusjuhud

Generaatorid on mitmekülgsed ja neid saab rakendada laias valikus stsenaariumides. Siin on mõned levinumad kasutusjuhud:

1. Kohandatud iteraatorid

Generaatorid lihtsustavad kohandatud iteraatorite loomist keerukate andmestruktuuride või algoritmide jaoks. Selle asemel, et käsitsi implementeerida next() meetodit ja hallata olekut, saate kasutada yield-i väärtuste kontrollitud viisil tootmiseks.

Näide: kahendpuu itereerimine

            class Node {
 constructor(value) {
 this.value = value;
 this.left = null;
 this.right = null;
 }
}

class BinaryTree {
 constructor(root) {
 this.root = root;
 }

 *[Symbol.iterator]() {
 function* inOrderTraversal(node) {
 if (node) {
 yield* inOrderTraversal(node.left); // rekursiivselt anna väärtused vasakpoolsest alampuust
 yield node.value;
 yield* inOrderTraversal(node.right); // rekursiivselt anna väärtused parempoolsest alampuust
 }
 }
 yield* inOrderTraversal(this.root);
 }
}

// Loo näidis kahendpuu
const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);

const tree = new BinaryTree(root);

// Itereeri üle puu, kasutades kohandatud iteraatorit
for (const value of tree) {
 console.log(value); // Väljund: 4, 2, 5, 1, 3
}

            

              
                Copy
              
            
          

See näide demonstreerib, kuidas generaatorfunktsioon inOrderTraversal rekursiivselt läbib kahendpuud ja annab väärtused in-order järjestuses. yield* süntaksit kasutatakse iteratsiooni delegeerimiseks teisele itereeritavale (antud juhul rekursiivsetele kutsetele inOrderTraversal-ile), lamedades efektiivselt pesastatud itereeritava.

2. Lõpmatud jadad

Generaatoreid saab kasutada lõpmatute väärtuste jadade loomiseks, nagu Fibonacci numbrid või algarvud. Kuna generaatorid toodavad väärtusi nõudmisel, ei tarbi nad mälu enne, kui väärtust tegelikult küsitakse.

Näide: Fibonacci numbrite genereerimine

            function* fibonacciGenerator() {
 let a = 0;
 let b = 1;
 while (true) {
 yield a;
 [a, b] = [b, a + b];
 }
}

const fib = fibonacciGenerator();

console.log(fib.next().value); // Väljund: 0
console.log(fib.next().value); // Väljund: 1
console.log(fib.next().value); // Väljund: 1
console.log(fib.next().value); // Väljund: 2
console.log(fib.next().value); // Väljund: 3
// ... ja nii edasi

            

              
                Copy
              
            
          

Funktsioon fibonacciGenerator genereerib lõpmatu jada Fibonacci numbreid. Tsükkel while (true) tagab, et generaator jätkab väärtuste tootmist lõpmatuseni. Kuna väärtused genereeritakse nõudmisel, saab see generaator esindada lõpmatut jada ilma lõpmatut mälu tarbimata.

3. Asünkroonne programmeerimine

Generaatoritel on oluline roll asünkroonses programmeerimises, eriti kui neid kombineerida promise'idega. Neid saab kasutada asünkroonse koodi kirjutamiseks, mis näeb välja ja käitub nagu sünkroonne kood, muutes selle lugemise ja mõistmise lihtsamaks.

Näide: asünkroonne andmete toomine generaatoritega

            function fetchData(url) {
 return new Promise((resolve, reject) => {
 fetch(url)
 .then(response => response.json())
 .then(data => resolve(data))
 .catch(error => reject(error));
 });
}

function* dataFetcher() {
 try {
 const user = yield fetchData('https://jsonplaceholder.typicode.com/users/1');
 console.log('Kasutaja:', user);
 const posts = yield fetchData(`https://jsonplaceholder.typicode.com/posts?userId=${user.id}`);
 console.log('Postitused:', posts);
 } catch (error) {
 console.error('Viga andmete toomisel:', error);
 }
}

function runGenerator(generator) {
 const iterator = generator();

 function iterate(result) {
 if (result.done) return;

 const promise = result.value;

 promise
 .then(value => iterate(iterator.next(value)))
 .catch(error => iterator.throw(error));
 }

 iterate(iterator.next());
}

runGenerator(dataFetcher);

            

              
                Copy
              
            
          

Selles näites toob generaatorfunktsioon dataFetcher asünkroonselt kasutaja ja postituste andmeid, kasutades funktsiooni fetchData, mis tagastab promise'i. Võtmesõna yield peatab generaatori, kuni promise laheneb, võimaldades teil kirjutada asünkroonset koodi järjestikuses, sünkroonse sarnases stiilis. Funktsioon runGenerator on abifunktsioon, mis juhib generaatorit, käsitledes promise'ide lahendamist ja vigade levitamist.

Kuigi kaasaegses asünkroonses JavaScriptis eelistatakse sageli `async/await`-i, annab generaatorite varasema (ja mõnikord siiani) kasutuse mõistmine asünkroonse kontrollivoo jaoks väärtusliku sissevaate keele arengusse.

4. Andmevoog ja töötlemine

Generaatoreid saab kasutada suurte andmekogumite või andmevoogude töötlemiseks mäluefektiivsel viisil. Andmetükkide järkjärgulise andmisega saate vältida kogu andmestiku korraga mällu laadimist.

Näide: suure CSV-faili töötlemine

            const fs = require('fs');
const readline = require('readline');

async function* processCSV(filePath) {
 const fileStream = fs.createReadStream(filePath);

 const rl = readline.createInterface({
 input: fileStream,
 crlfDelay: Infinity
 });

 for await (const line of rl) {
 // Töötle iga rida (nt parsi CSV andmed)
 const data = line.split(',');
 yield data;
 }
}

async function main() {
 const csvGenerator = processCSV('large_data.csv');

 for await (const row of csvGenerator) {
 console.log('Rida:', row);
 // Teosta operatsioone igal real
 }
}

main();

            

              
                Copy
              
            
          

See näide kasutab fs ja readline mooduleid suure CSV-faili lugemiseks rida-realt. Generaatorfunktsioon processCSV annab iga CSV-faili rea massiivina. async/await süntaksit kasutatakse failiridade asünkroonseks itereerimiseks, tagades, et faili töödeldakse efektiivselt ilma peamist lõime blokeerimata. Võti on siin iga rea töötlemine *selle lugemise ajal*, mitte katse laadida kogu CSV esmalt mällu.

Täiustatud generaatoritehnikad

1. Generaatorite kompositsioon `yield*`-ga

Võtmesõna yield* võimaldab teil delegeerida iteratsiooni teisele itereeritavale objektile või generaatorile. See on kasulik keerukate iteraatorite koostamiseks lihtsamatest.

Näide: mitme generaatori kombineerimine

            function* generator1() {
 yield 1;
 yield 2;
}

function* generator2() {
 yield 3;
 yield 4;
}

function* combinedGenerator() {
 yield* generator1();
 yield* generator2();
 yield 5;
}

const combined = combinedGenerator();

console.log(combined.next()); // Väljund: { value: 1, done: false }
console.log(combined.next()); // Väljund: { value: 2, done: false }
console.log(combined.next()); // Väljund: { value: 3, done: false }
console.log(combined.next()); // Väljund: { value: 4, done: false }
console.log(combined.next()); // Väljund: { value: 5, done: false }
console.log(combined.next()); // Väljund: { value: undefined, done: true }

            

              
                Copy
              
            
          

Funktsioon combinedGenerator kombineerib väärtused generaatoritest generator1 ja generator2 koos täiendava väärtusega 5. Võtmesõna yield* lamedab efektiivselt pesastatud iteraatorid, tootes üheainsa väärtuste jada.

2. Väärtuste saatmine generaatoritele `next()`-ga

Generaatori objekti next() meetod võib aktsepteerida argumenti, mis seejärel edastatakse yield-avalduse väärtusena generaatorfunktsioonis. See võimaldab kahesuunalist suhtlust generaatori ja kutsuja vahel.

Näide: interaktiivne generaator

            function* interactiveGenerator() {
 const input1 = yield 'Mis on sinu nimi?';
 console.log('Saadud nimi:', input1);

 const input2 = yield 'Mis on sinu lemmikvärv?';
 console.log('Saadud värv:', input2);

 return `Tere, ${input1}! Sinu lemmikvärv on ${input2}.`;
}

const interactive = interactiveGenerator();

console.log(interactive.next().value); // Väljund: Mis on sinu nimi?
console.log(interactive.next('Alice').value); // Väljund: Saadud nimi: Alice
 // Väljund: Mis on sinu lemmikvärv?
console.log(interactive.next('Sinine').value); // Väljund: Saadud värv: Sinine
 // Väljund: Tere, Alice! Sinu lemmikvärv on Sinine.
console.log(interactive.next()); // Väljund: { value: Tere, Alice! Sinu lemmikvärv on Sinine., done: true }

            

              
                Copy
              
            
          

Selles näites küsib funktsioon interactiveGenerator kasutajalt nime ja lemmikvärvi. Meetodit next() kasutatakse kasutaja sisendi tagasi saatmiseks generaatorile, mis seejärel kasutab seda isikupärastatud tervituse koostamiseks. See illustreerib, kuidas generaatoreid saab kasutada interaktiivsete programmide loomiseks, mis reageerivad välisele sisendile.

3. Vigade käsitlemine `throw()`-ga

Generaatori objekti throw() meetodit saab kasutada erandi viskamiseks generaatorfunktsiooni sees. See võimaldab vigade käsitlemist ja puhastamist generaatori kontekstis.

Näide: vigade käsitlemine generaatoris

            function* errorGenerator() {
 try {
 yield 'Alustan...';
 throw new Error('Midagi läks valesti!');
 yield 'Seda ei täideta.';
 } catch (error) {
 console.error('Püütud viga:', error.message);
 yield 'Taastun...';
 }
 yield 'Lõpetatud.';
}

const errorGen = errorGenerator();

console.log(errorGen.next().value); // Väljund: Alustan...
console.log(errorGen.next().value); // Väljund: Püütud viga: Midagi läks valesti!
 // Väljund: Taastun...
console.log(errorGen.next().value); // Väljund: Lõpetatud.
console.log(errorGen.next().value); // Väljund: undefined

            

              
                Copy
              
            
          

Selles näites viskab funktsioon errorGenerator vea try...catch ploki sees. Plokk catch käsitleb viga ja annab taasteteate. See demonstreerib, kuidas generaatoreid saab kasutada vigade sujuvaks käsitlemiseks ja täitmise jätkamiseks.

4. Väärtuste tagastamine `return()`-ga

Generaatori objekti return() meetodit saab kasutada generaatori enneaegseks lõpetamiseks ja kindla väärtuse tagastamiseks. See võib olla kasulik ressursside puhastamiseks või jada lõpu signaalimiseks.

Näide: generaatori varajane lõpetamine

            function* earlyExitGenerator() {
 yield 1;
 yield 2;
 return 'Varajane väljumine!';
 yield 3; // Seda ei täideta
}

const exitGen = earlyExitGenerator();

console.log(exitGen.next().value); // Väljund: 1
console.log(exitGen.next().value); // Väljund: 2
console.log(exitGen.next().value); // Väljund: Varajane väljumine!
console.log(exitGen.next().value); // Väljund: undefined
console.log(exitGen.next().done); // Väljund: true

            

              
                Copy
              
            
          

Selles näites lõpetab funktsioon earlyExitGenerator varakult, kui see kohtub return lausega. Meetod return() tagastab määratud väärtuse ja seab done omaduse väärtuseks true, mis näitab, et generaator on lõpule jõudnud.

JavaScripti generaatorite kasutamise eelised

• Parem koodi loetavus: Generaatorid võimaldavad teil kirjutada iteratiivset koodi järjestikusemas ja sünkroonse sarnases stiilis, muutes selle lugemise ja mõistmise lihtsamaks.
• Lihtsustatud asünkroonne programmeerimine: Generaatoreid saab kasutada asünkroonse koodi lihtsustamiseks, muutes tagasikutsete ja promise'ide haldamise lihtsamaks.
• Mäluefektiivsus: Generaatorid toodavad väärtusi nõudmisel, mis võib olla mäluefektiivsem kui tervete andmekogumite loomine ja mälus hoidmine.
• Kohandatud iteraatorid: Generaatorid muudavad kohandatud iteraatorite loomise keerukate andmestruktuuride või algoritmide jaoks lihtsaks.
• Koodi taaskasutatavus: Generaatoreid saab koostada ja taaskasutada erinevates kontekstides, edendades koodi taaskasutatavust ja hooldatavust.

Kokkuvõte

JavaScripti generaatorid on võimas tööriist kaasaegses JavaScripti arenduses. Need pakuvad lühikest ja elegantset viisi iteraatori protokolli rakendamiseks, asünkroonse programmeerimise lihtsustamiseks ja suurte andmekogumite tõhusaks töötlemiseks. Generaatorite ja nende täiustatud tehnikate valdamisega saate kirjutada loetavamat, hooldatavamat ja jõudlusvõimelisemat koodi. Olgu tegemist keerukate andmestruktuuride ehitamise, asünkroonsete operatsioonide töötlemise või andmete voogedastusega, generaatorid aitavad teil lahendada laia valikut probleeme kerguse ja elegantsiga. Generaatorite omaksvõtt kahtlemata täiustab teie JavaScripti programmeerimisoskusi ja avab uusi võimalusi teie projektidele.

Jätkates JavaScripti avastamist, pidage meeles, et generaatorid on vaid üks osa puslest. Nende kombineerimine teiste kaasaegsete funktsioonidega nagu promise'id, async/await ja noolefunktsioonid võib viia veelgi võimsama ja väljendusrikkama koodini. Jätkake katsetamist, jätkake õppimist ja jätkake imeliste asjade ehitamist!